package com.newlink.building.obfuscation.integration

import android.content.Context
import com.newlink.building.obfuscation.Module_Obfuscation_ObfuscationHelper
import com.newlink.building.obfuscation.Module_Obfuscation_ObfuscationInvoker

/**
 * 集成示例
 * 展示如何在其他模块中集成混淆调用
 *
 * 使用说明：
 * 1. 在关键业务逻辑前后插入混淆调用
 * 2. 在网络请求、数据库操作、用户交互等地方添加混淆
 * 3. 不要在性能敏感的地方过度使用
 */
class Module_Obfuscation_IntegrationExample {

    /**
     * 示例1：在登录功能中集成混淆
     */
    fun loginWithObfuscation(username: String, password: String): Boolean {
        // 方法进入时混淆
        Module_Obfuscation_ObfuscationHelper.onMethodEnter("IntegrationExample", "loginWithObfuscation")

        // 参数混淆
        Module_Obfuscation_ObfuscationInvoker.invokeRandom(username)
        Module_Obfuscation_ObfuscationInvoker.invokeRandom(password)

        // 实际的登录逻辑
        val loginResult = performActualLogin(username, password)

        // 结果混淆
        Module_Obfuscation_ObfuscationHelper.onMethodExit("IntegrationExample", "loginWithObfuscation", loginResult)

        return loginResult
    }

    /**
     * 示例2：在数据处理中集成混淆
     */
    fun processDataWithObfuscation(data: List<String>): List<String> {
        // 使用包装器执行方法
        return Module_Obfuscation_ObfuscationHelper.wrapMethodCall {
            // 数据处理前混淆
            Module_Obfuscation_ObfuscationHelper.beforeDatabaseOperation("process", data)

            // 实际的数据处理
            val processed = data.map { item ->
                // 在循环中添加混淆
                Module_Obfuscation_ObfuscationHelper.inLoop(data.indexOf(item), item)
                item.uppercase()
            }

            // 返回处理后的数据
            processed
        }
    }

    /**
     * 示例3：在网络请求中集成混淆
     */
    suspend fun fetchDataWithObfuscation(url: String, params: Map<String, Any>): String {
        // 请求前混淆
        Module_Obfuscation_ObfuscationHelper.beforeNetworkRequest(url, params)

        try {
            // 模拟网络请求
            val response = simulateNetworkRequest(url, params)

            // 响应后混淆
            Module_Obfuscation_ObfuscationHelper.afterNetworkResponse(response)

            return response
        } catch (e: Exception) {
            // 异常时混淆
            Module_Obfuscation_ObfuscationHelper.onException(e)
            throw e
        }
    }

    /**
     * 示例4：在UI事件处理中集成混淆
     */
    fun onButtonClickWithObfuscation(buttonId: Int) {
        // UI事件混淆
        Module_Obfuscation_ObfuscationHelper.onUiEvent("button_click", buttonId)

        // 条件执行混淆
        val shouldProcess = Module_Obfuscation_ObfuscationHelper.beforeCondition(buttonId > 0)

        if (shouldProcess) {
            // 链式调用混淆方法
            Module_Obfuscation_ObfuscationInvoker.invokeChain(
                intArrayOf(1, 5, 9, 13),
                buttonId
            )

            // 实际的按钮处理逻辑
            handleButtonClick(buttonId)
        }

        // 生成混淆的日志
        Module_Obfuscation_ObfuscationHelper.obfuscatedLog("UI", "Button clicked: $buttonId")
    }

    /**
     * 示例5：在定时任务中集成混淆
     */
    fun scheduleTaskWithObfuscation(taskName: String, delayMillis: Long) {
        // 定时任务混淆
        Module_Obfuscation_ObfuscationHelper.onScheduledTask(taskName)

        // 延迟混淆
        Module_Obfuscation_ObfuscationHelper.delayedObfuscation(delayMillis, taskName)

        // 批量执行混淆
        Module_Obfuscation_ObfuscationInvoker.invokeBatch(5, taskName)

        // 实际的定时任务逻辑
        scheduleActualTask(taskName, delayMillis)
    }

    /**
     * 示例6：在数据验证中集成混淆
     */
    fun validateDataWithObfuscation(data: Any): Boolean {
        // 生成混淆ID
        val validationId = Module_Obfuscation_ObfuscationHelper.generateObfuscatedId("validation")

        // 验证并混淆
        val isValid = Module_Obfuscation_ObfuscationHelper.validateAndObfuscate(data)

        // 条件混淆调用
        Module_Obfuscation_ObfuscationInvoker.invokeConditional(
            isValid,
            trueMethod = 10,
            falseMethod = 15,
            data = validationId
        )

        // 获取混淆时间戳
        val timestamp = Module_Obfuscation_ObfuscationHelper.getObfuscatedTimestamp()

        // 异步混淆
        Module_Obfuscation_ObfuscationInvoker.invokeAsync(7, timestamp) { result ->
            // 异步回调中的混淆逻辑
            println("Async obfuscation result: $result")
        }

        return isValid
    }

    /**
     * 示例7：在初始化中集成混淆
     */
    fun initializeWithObfuscation(context: Context) {
        // 初始化时的混淆
        Module_Obfuscation_ObfuscationHelper.onMethodEnter("IntegrationExample", "initialize")

        // 获取混淆统计
        val stats = Module_Obfuscation_ObfuscationInvoker.getStatistics()

        // 使用统计信息进行混淆
        Module_Obfuscation_ObfuscationInvoker.invokeSpecific(
            stats["counter"]?.hashCode() ?: 0,
            context.packageName
        )

        // 实际的初始化逻辑
        performInitialization(context)

        // 清理混淆缓存
        if (stats["counter"] as Long > 1000) {
            Module_Obfuscation_ObfuscationHelper.clearObfuscationCache()
        }
    }

    // ========== 模拟的实际业务方法 ==========

    private fun performActualLogin(username: String, password: String): Boolean {
        // 模拟登录逻辑
        return username.isNotEmpty() && password.isNotEmpty()
    }

    private suspend fun simulateNetworkRequest(url: String, params: Map<String, Any>): String {
        // 模拟网络请求
        return "Response from $url with ${params.size} params"
    }

    private fun handleButtonClick(buttonId: Int) {
        // 模拟按钮处理逻辑
        println("Handling button: $buttonId")
    }

    private fun scheduleActualTask(taskName: String, delayMillis: Long) {
        // 模拟定时任务逻辑
        println("Scheduling task: $taskName with delay: $delayMillis")
    }

    private fun performInitialization(context: Context) {
        // 模拟初始化逻辑
        println("Initializing with context: ${context.packageName}")
    }
}

/**
 * 使用建议：
 *
 * 1. 在 MainActivity 的 onCreate 中：
 *    ObfuscationHelper.onMethodEnter("MainActivity", "onCreate")
 *    // 原有逻辑
 *    ObfuscationHelper.onMethodExit("MainActivity", "onCreate", null)
 *
 * 2. 在网络请求类中：
 *    ObfuscationHelper.beforeNetworkRequest(url, params)
 *    // 发起请求
 *    ObfuscationHelper.afterNetworkResponse(response)
 *
 * 3. 在数据库操作中：
 *    ObfuscationHelper.beforeDatabaseOperation("insert", data)
 *    // 执行数据库操作
 *
 * 4. 在敏感操作前后：
 *    ObfuscationInvoker.invokeRandom(sensitiveData)
 *    // 执行敏感操作
 *    ObfuscationInvoker.invokeBatch(3, result)
 *
 * 5. 在循环中（注意性能）：
 *    for (i in 0 until items.size) {
 *        if (i % 10 == 0) {  // 每10次循环混淆一次
 *            ObfuscationHelper.inLoop(i, items[i])
 *        }
 *        // 处理逻辑
 *    }
 */